// stdexcept standard header
#pragma once
#ifndef _STDEXCEPT_
#define _STDEXCEPT_
#ifndef RC_INVOKED
#include <exception>
#include <xstring>

#pragma pack(push, _CRT_PACKING)
#pragma warning(push, _STL_WARNING_LEVEL)
#pragma warning(disable : _STL_DISABLED_WARNINGS)
_STL_DISABLE_CLANG_WARNINGS
#pragma push_macro("new")
#undef new
_STD_BEGIN
// CLASS logic_error
class logic_error : public exception { // base of all logic-error exceptions
public:
    using _Mybase = exception;

    explicit logic_error(const string& _Message) : _Mybase(_Message.c_str()) { // construct from message string
    }

    explicit logic_error(const char* _Message) : _Mybase(_Message) { // construct from message string
    }

#if _HAS_EXCEPTIONS

#else // _HAS_EXCEPTIONS
protected:
    virtual void _Doraise() const { // perform class-specific exception handling
        _RAISE(*this);
    }
#endif // _HAS_EXCEPTIONS
};

// CLASS domain_error
class domain_error : public logic_error { // base of all domain-error exceptions
public:
    using _Mybase = logic_error;

    explicit domain_error(const string& _Message) : _Mybase(_Message.c_str()) { // construct from message string
    }

    explicit domain_error(const char* _Message) : _Mybase(_Message) { // construct from message string
    }

#if _HAS_EXCEPTIONS

#else // _HAS_EXCEPTIONS
protected:
    virtual void _Doraise() const { // perform class-specific exception handling
        _RAISE(*this);
    }
#endif // _HAS_EXCEPTIONS
};

// CLASS invalid_argument
class invalid_argument : public logic_error { // base of all invalid-argument exceptions
public:
    using _Mybase = logic_error;

    explicit invalid_argument(const string& _Message) : _Mybase(_Message.c_str()) { // construct from message string
    }

    explicit invalid_argument(const char* _Message) : _Mybase(_Message) { // construct from message string
    }

#if _HAS_EXCEPTIONS

#else // _HAS_EXCEPTIONS
protected:
    virtual void _Doraise() const { // perform class-specific exception handling
        _RAISE(*this);
    }
#endif // _HAS_EXCEPTIONS
};

// CLASS length_error
class length_error : public logic_error { // base of all length-error exceptions
public:
    using _Mybase = logic_error;

    explicit length_error(const string& _Message) : _Mybase(_Message.c_str()) { // construct from message string
    }

    explicit length_error(const char* _Message) : _Mybase(_Message) { // construct from message string
    }

#if _HAS_EXCEPTIONS

#else // _HAS_EXCEPTIONS
protected:
    virtual void _Doraise() const { // perform class-specific exception handling
        _RAISE(*this);
    }
#endif // _HAS_EXCEPTIONS
};

// CLASS out_of_range
class out_of_range : public logic_error { // base of all out-of-range exceptions
public:
    using _Mybase = logic_error;

    explicit out_of_range(const string& _Message) : _Mybase(_Message.c_str()) { // construct from message string
    }

    explicit out_of_range(const char* _Message) : _Mybase(_Message) { // construct from message string
    }

#if _HAS_EXCEPTIONS

#else // _HAS_EXCEPTIONS
protected:
    virtual void _Doraise() const { // perform class-specific exception handling
        _RAISE(*this);
    }
#endif // _HAS_EXCEPTIONS
};

// CLASS runtime_error
class runtime_error : public exception { // base of all runtime-error exceptions
public:
    using _Mybase = exception;

    explicit runtime_error(const string& _Message) : _Mybase(_Message.c_str()) { // construct from message string
    }

    explicit runtime_error(const char* _Message) : _Mybase(_Message) { // construct from message string
    }

#if _HAS_EXCEPTIONS

#else // _HAS_EXCEPTIONS
protected:
    virtual void _Doraise() const { // perform class-specific exception handling
        _RAISE(*this);
    }
#endif // _HAS_EXCEPTIONS
};

// CLASS overflow_error
class overflow_error : public runtime_error { // base of all overflow-error exceptions
public:
    using _Mybase = runtime_error;

    explicit overflow_error(const string& _Message) : _Mybase(_Message.c_str()) { // construct from message string
    }

    explicit overflow_error(const char* _Message) : _Mybase(_Message) { // construct from message string
    }

#if _HAS_EXCEPTIONS

#else // _HAS_EXCEPTIONS
protected:
    virtual void _Doraise() const { // perform class-specific exception handling
        _RAISE(*this);
    }
#endif // _HAS_EXCEPTIONS
};

// CLASS underflow_error
class underflow_error : public runtime_error { // base of all underflow-error exceptions
public:
    using _Mybase = runtime_error;

    explicit underflow_error(const string& _Message) : _Mybase(_Message.c_str()) { // construct from message string
    }

    explicit underflow_error(const char* _Message) : _Mybase(_Message) { // construct from message string
    }

#if _HAS_EXCEPTIONS

#else // _HAS_EXCEPTIONS
protected:
    virtual void _Doraise() const { // perform class-specific exception handling
        _RAISE(*this);
    }
#endif // _HAS_EXCEPTIONS
};

// CLASS range_error
class range_error : public runtime_error { // base of all range-error exceptions
public:
    using _Mybase = runtime_error;

    explicit range_error(const string& _Message) : _Mybase(_Message.c_str()) { // construct from message string
    }

    explicit range_error(const char* _Message) : _Mybase(_Message) { // construct from message string
    }

#if _HAS_EXCEPTIONS

#else // _HAS_EXCEPTIONS
protected:
    virtual void _Doraise() const { // perform class-specific exception handling
        _RAISE(*this);
    }
#endif // _HAS_EXCEPTIONS
};
_STD_END
#pragma pop_macro("new")
_STL_RESTORE_CLANG_WARNINGS
#pragma warning(pop)
#pragma pack(pop)
#endif // RC_INVOKED
#endif // _STDEXCEPT_

/*
 * Copyright (c) by P.J. Plauger. All rights reserved.
 * Consult your license regarding permissions and restrictions.
V6.50:0009 */
